/*******************************************************************************
* Copyright (c) 2013, 2017 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
******************************************************************************/
package org.eclipse.ui.tests.leaks;
import java.lang.ref.WeakReference;
import java.util.Collections;
import java.util.Map;
import org.eclipse.ui.AbstractSourceProvider;
import org.eclipse.ui.ISourceProviderListener;
import org.junit.Assert;
import org.junit.Test;
/**
* @since 3.5
*
*/
public class Bug397302Tests {
/**
* @since 3.5
*
*/
private static class TestListener implements ISourceProviderListener {
private long callCount = 0;
public long getCallCount() {
return callCount;
}
/**
*/
public TestListener() {
}
@Override
public void sourceChanged(int sourcePriority, String sourceName,
Object sourceValue) {
++callCount;
}
@Override
public void sourceChanged(int sourcePriority, Map sourceValuesByName) {
++callCount;
}
}
private static final class TestSourceProvider extends AbstractSourceProvider {
@Override
public void dispose() {
// do nothing
}
@Override
public Map getCurrentState() {
return Collections.EMPTY_MAP;
}
@Override
public String[] getProvidedSourceNames() {
return new String[] {};
}
/**
*
*/
public void callOut() {
this.fireSourceChanged(0, Collections.EMPTY_MAP);
}
}
/**
* Reproduce the problem, as described in the bug report.
*/
@Test
public void testBugAsDescribed() {
final TestSourceProvider testSourceProvider = new TestSourceProvider();
TestListener a = new TestListener();
TestListener b = new TestListener();
// keep weak references so we can check on the GC status later on...
final WeakReference<TestListener> listenerARef = new WeakReference<>(a);
final WeakReference<TestListener> listenerBRef = new WeakReference<>(b);
// add listeners, call out the them, and verify that they got called.
testSourceProvider.addSourceProviderListener(a);
testSourceProvider.addSourceProviderListener(b);
testSourceProvider.callOut();
Assert.assertEquals(1, a.getCallCount());
Assert.assertEquals(1, b.getCallCount());
// remove listeners, call out to them, and verify that they no longer got called
testSourceProvider.removeSourceProviderListener(a);
testSourceProvider.removeSourceProviderListener(b);
testSourceProvider.callOut();
Assert.assertEquals(1, a.getCallCount());
Assert.assertEquals(1, b.getCallCount());
// loose our strong references to a & b, force a GC, and see whether either gets leaked.
// Test: The bug asserts that B has been leaked. Force a GC, and test whether
// our weak references have gone null of not. If there is no leak, then both
// should be null.
a = null;
b = null;
System.gc();
Assert.assertNull("Reference A", listenerARef.get());
Assert.assertNull("Reference B", listenerBRef.get());
// Need this to prevent the above GC call from sweeping everything up before we're ready.
// See this only when NOT in debug.
testSourceProvider.callOut();
}
/**
* Test that removal during call out does not cause problems.
*/
@Test
public void testRemoveDuringCallOut() {
final TestSourceProvider testSourceProvider = new TestSourceProvider();
final TestListener testListener = new TestListener() {
@Override
public void sourceChanged(int sourcePriority, Map sourceValuesByName) {
testSourceProvider.removeSourceProviderListener(this);
}
};
testSourceProvider.addSourceProviderListener(testListener);
// With improper protection, this was can through something like ConcurrentModificationException
testSourceProvider.callOut();
}
}